Replace leftover gtk-doc syntax (#Type) with backquotes.
/**
* GDK_WINDOWING_X11:
*
- * The #GDK_WINDOWING_X11 macro is defined if the X11 backend
+ * The `GDK_WINDOWING_X11` macro is defined if the X11 backend
* is supported.
*
* Use this macro to guard code that is specific to the X11 backend.
/**
* GDK_WINDOWING_WIN32:
*
- * The #GDK_WINDOWING_WIN32 macro is defined if the Win32 backend
+ * The `GDK_WINDOWING_WIN32` macro is defined if the Win32 backend
* is supported.
*
* Use this macro to guard code that is specific to the Win32 backend.
/**
* GDK_WINDOWING_MACOS:
*
- * The #GDK_WINDOWING_MACOS macro is defined if the MacOS backend
+ * The `GDK_WINDOWING_MACOS` macro is defined if the MacOS backend
* is supported.
*
* Use this macro to guard code that is specific to the MacOS backend.
/**
* GDK_WINDOWING_WAYLAND:
*
- * The #GDK_WINDOWING_WAYLAND macro is defined if the Wayland backend
+ * The `GDK_WINDOWING_WAYLAND` macro is defined if the Wayland backend
* is supported.
*
* Use this macro to guard code that is specific to the Wayland backend.
/**
* gdk_app_launch_context_set_icon:
* @context: a `GdkAppLaunchContext`
- * @icon: (nullable): a #GIcon
+ * @icon: (nullable): a `GIcon`
*
* Sets the icon for applications that are launched with this
* context.
/**
* gdk_cairo_set_source_rgba:
* @cr: a cairo context
- * @rgba: a #GdkRGBA
+ * @rgba: a `GdkRGBA`
*
- * Sets the specified #GdkRGBA as the source color of @cr.
+ * Sets the specified `GdkRGBA` as the source color of @cr.
*/
void
gdk_cairo_set_source_rgba (cairo_t *cr,
/**
* gdk_cairo_rectangle:
* @cr: a cairo context
- * @rectangle: a #GdkRectangle
+ * @rectangle: a `GdkRectangle`
*
* Adds the given rectangle to the current path of @cr.
*/
/**
* gdk_cairo_region:
* @cr: a cairo context
- * @region: a #cairo_region_t
+ * @region: a `cairo_region_t`
*
* Adds the given region to the current path of @cr.
*/
/**
* gdk_cairo_set_source_pixbuf:
* @cr: a cairo context
- * @pixbuf: a #GdkPixbuf
+ * @pixbuf: a `GdkPixbuf`
* @pixbuf_x: X coordinate of location to place upper left corner of @pixbuf
* @pixbuf_y: Y coordinate of location to place upper left corner of @pixbuf
*
* You must explicitly check the return value of you want to handle
* that case.
*
- * Returns: %TRUE if the extents fit in a #GdkRectangle, %FALSE if not
+ * Returns: %TRUE if the extents fit in a `GdkRectangle`, %FALSE if not
*/
gboolean
_gdk_cairo_surface_extents (cairo_surface_t *surface,
/**
* gdk_cairo_context_cairo_create:
- * @self: a #GdkCairoContext that is currently drawing
+ * @self: a `GdkCairoContext` that is currently drawing
*
* Retrieves a Cairo context to be used to draw on the `GdkSurface`
* of @context.
* @clipboard: a `GdkClipboard`
* @type: a `GType` to read
* @io_priority: the I/O priority of the request
- * @cancellable: (nullable): optional #GCancellable object, %NULL to ignore.
+ * @cancellable: (nullable): optional `GCancellable` object
* @callback: (scope async): callback to call when the request is satisfied
* @user_data: (closure): the data to pass to callback function
*
/**
* GdkContentDeserializeFunc:
- * @deserializer: a #GdkContentDeserializer
+ * @deserializer: a `GdkContentDeserializer`
*
* The type of a function that can be registered with gdk_content_register_deserializer().
*
*
* Checks if a given `GType` is part of the given @formats.
*
- * Returns: %TRUE if the #GType was found
+ * Returns: %TRUE if the `GType` was found
*/
gboolean
gdk_content_formats_contain_gtype (const GdkContentFormats *formats,
*
* Gets the `GType`s included in @formats.
*
- * Note that @formats may not contain any #GTypes, in particular when
+ * Note that @formats may not contain any `GType`s, in particular when
* they are empty. In that case %NULL will be returned.
*
* Returns: (transfer none) (nullable) (array length=n_gtypes zero-terminated=1):
/**
* gdk_content_provider_ref_formats: (attributes org.gtk.Method.get_property=formats)
- * @provider: a #GdkContentProvider
+ * @provider: a `GdkContentProvider`
*
* Gets the formats that the provider can provide its current contents in.
*
/**
* gdk_content_provider_ref_storable_formats: (attributes org.gtk.Method.get_property=storable-formats)
- * @provider: a #GdkContentProvider
+ * @provider: a `GdkContentProvider`
*
* Gets the formats that the provider suggests other applications to store
* the data in.
*
* The given mime type does not need to be listed in the formats returned by
* [method@Gdk.ContentProvider.ref_formats]. However, if the given `GType` is
- * not supported, #G_IO_ERROR_NOT_SUPPORTED will be reported.
+ * not supported, `G_IO_ERROR_NOT_SUPPORTED` will be reported.
*
* The given @stream will not be closed.
*/
* provided in. This given `GType` does not need to be listed in the formats
* returned by [method@Gdk.ContentProvider.ref_formats]. However, if the
* given `GType` is not supported, this operation can fail and
- * #G_IO_ERROR_NOT_SUPPORTED will be reported.
+ * `G_IO_ERROR_NOT_SUPPORTED` will be reported.
*
* Returns: %TRUE if the value was set successfully. Otherwise
* @error will be set to describe the failure.
/**
* GdkContentProviderClass:
- * @content_changed: Signal class closure for #GdkContentProvider::content-changed
+ * @content_changed: Signal class closure for `GdkContentProvider::content-changed`
*
- * Class structure for #GdkContentProvider.
+ * Class structure for `GdkContentProvider`.
*/
struct _GdkContentProviderClass
{
/**
* gdk_content_provider_new_union:
* @providers: (nullable) (array length=n_providers) (transfer full):
- * The #GdkContentProviders to present the union of
+ * The `GdkContentProvider`s to present the union of
* @n_providers: the number of providers
*
* Creates a content provider that represents all the given @providers.
* @mime_type: the mime type to serialize to
* @value: the content to serialize
* @io_priority: the I/O priority of the operation
- * @cancellable: (nullable): optional #GCancellable object
+ * @cancellable: (nullable): optional `GCancellable` object
* @callback: (scope async): callback to call when the operation is done
* @user_data: (closure): data to pass to the callback function
*
/**
* GdkContentSerializeFunc:
- * @serializer: a #GdkContentSerializer
+ * @serializer: a `GdkContentSerializer`
*
* The type of a function that can be registered with gdk_content_register_serializer().
*
/**
* gdk_cursor_get_texture:
- * @cursor: a #GdkCursor.
+ * @cursor: a `GdkCursor`
*
* Returns the texture for the cursor.
*
/**
* GdkDevice:display: (attributes org.gtk.Property.get=gdk_device_get_display)
*
- * The #GdkDisplay the #GdkDevice pertains to.
+ * The `GdkDisplay` the `GdkDevice` pertains to.
*/
device_props[PROP_DISPLAY] =
g_param_spec_object ("display",
/**
* gdk_device_get_seat: (attributes org.gtk.Method.get_property=seat)
- * @device: A #GdkDevice
+ * @device: A `GdkDevice`
*
* Returns the `GdkSeat` the device belongs to.
*
/**
* GdkTimeCoord:
- * @time: The timestamp for this event.
+ * @time: The timestamp for this event
* @flags: Flags indicating what axes are present
* @axes: (array fixed-size=12): axis values
*
- * A #GdkTimeCoord stores a single event in a motion history.
+ * A `GdkTimeCoord` stores a single event in a motion history.
*/
struct _GdkTimeCoord
{
* (current) for each given group, different groups may have different
* current modes. The number of available modes in a group can be found
* out through [method@Gdk.DevicePad.get_group_n_modes], and the current mode
- * for a given group will be notified through events of type #GDK_PAD_GROUP_MODE.
+ * for a given group will be notified through events of type `GDK_PAD_GROUP_MODE`.
*/
#include "config.h"
x, y, width, height);
}
-/**
+/*< private >
* gdk_display_get_keymap:
* @display: the `GdkDisplay`
*
- * Returns the #GdkKeymap attached to @display.
+ * Returns the `GdkKeymap` attached to @display.
*
- * Returns: (transfer none): the #GdkKeymap attached to @display.
+ * Returns: (transfer none): the `GdkKeymap` attached to @display.
*/
GdkKeymap *
gdk_display_get_keymap (GdkDisplay *display)
/*< private >
* gdk_display_make_gl_context_current:
- * @display: a #GdkDisplay
- * @context: (optional): a #GdkGLContext
+ * @display: a `GdkDisplay`
+ * @context: (optional): a `GdkGLContext`
*
* Makes the given @context the current GL context, or unsets
* the current GL context if @context is %NULL.
* You can listen to the GListModel::items-changed signal on
* this list to monitor changes to the monitor of this display.
*
- * Returns: (transfer none): a #GListModel of `GdkMonitor`
+ * Returns: (transfer none): a `GListModel` of `GdkMonitor`
*/
GListModel *
gdk_display_get_monitors (GdkDisplay *self)
*
* When writing backend-specific code that is supposed to work with
* multiple GDK backends, you have to consider both compile time and
- * runtime. At compile time, use the #GDK_WINDOWING_X11, #GDK_WINDOWING_WIN32
+ * runtime. At compile time, use the `GDK_WINDOWING_X11`, `GDK_WINDOWING_WIN32`
* macros, etc. to find out which backends are present in the GDK library
* you are building your application against. At runtime, use type-check
* macros like GDK_IS_X11_DISPLAY() to find out which backend is in use:
/**
* GdkDragSurface:
*
- * A #GdkDragSurface is an interface for surfaces used during DND.
+ * A `GdkDragSurface` is an interface for surfaces used during DND.
*/
/**
*
* Retrieves the surface that @context is bound to.
*
- * Returns: (nullable) (transfer none): the #GdkSurface
+ * Returns: (nullable) (transfer none): a `GdkSurface`
*/
GdkSurface *
gdk_draw_context_get_surface (GdkDrawContext *context)
/**
* gdk_draw_context_get_frame_region:
- * @context: a #GdkDrawContext
+ * @context: a `GdkDrawContext`
*
* Retrieves the region that is currently being repainted.
*
* @instance_size: the size of the instance of a GdkEvent subclass
* @instance_init: (nullable): the function to initialize the instance data
* @finalize: (nullable): the function to free the instance data
- * @get_state: (nullable): the function to retrieve the #GdkModifierType
+ * @get_state: (nullable): the function to retrieve the `GdkModifierType`:w
* associated to the event
* @get_position: (nullable): the function to retrieve the event coordinates
* @get_sequence: (nullable): the function to retrieve the event sequence
* Similarly to %G_DEFINE_TYPE_WITH_CODE, this macro will generate a `get_type()`
* function that registers the event type.
*
- * You can specify code to be run after the type registration; the #GType of
+ * You can specify code to be run after the type registration; the `GType` of
* the event is available in the `gdk_define_event_type_id` variable.
*/
#define GDK_DEFINE_EVENT_TYPE(TypeName, type_name, type_info, _C_) \
/*< private >
* gdk_event_alloc:
* @event_type: the `GdkEvent`Type to allocate
- * @surface: (nullable): the #GdkSurface of the event
- * @device: (nullable): the #GdkDevice of the event
+ * @surface: (nullable): the `GdkSurface` of the event
+ * @device: (nullable): the `GdkDevice` of the event
* @time_: the event serial
*
* Allocates a `GdkEvent` for the given @event_type, and sets its
/**
* _gdk_event_queue_find_first:
- * @display: a #GdkDisplay
- *
+ * @display: a `GdkDisplay`
+ *
* Find the first event on the queue that is not still
* being filled in.
- *
- * Returns: (nullable): Pointer to the list node for that event, or
- * %NULL.
- **/
+ *
+ * Returns: (nullable): Pointer to the list node for that event
+ */
GList*
_gdk_event_queue_find_first (GdkDisplay *display)
{
/**
* _gdk_event_queue_append:
- * @display: a #GdkDisplay
- * @event: Event to append.
- *
+ * @display: a `GdkDisplay`
+ * @event: Event to append
+ *
* Appends an event onto the tail of the event queue.
*
* Returns: the newly appended list node.
- **/
+ */
GList *
_gdk_event_queue_append (GdkDisplay *display,
GdkEvent *event)
/*
* _gdk_event_queue_remove_link:
- * @display: a #GdkDisplay
+ * @display: a `GdkDisplay`
* @node: node to remove
*
* Removes a specified list node from the event queue.
- **/
+ */
void
_gdk_event_queue_remove_link (GdkDisplay *display,
GList *node)
/*
* _gdk_event_unqueue:
- * @display: a #GdkDisplay
+ * @display: a `GdkDisplay`
*
* Removes and returns the first event from the event
* queue that is not still being filled in.
*
- * Returns: (nullable) (transfer full): the event
+ * Returns: (nullable): the event
*/
GdkEvent*
_gdk_event_unqueue (GdkDisplay *display)
*
* Extracts the surface associated with an event.
*
- * Returns: (transfer none): The #GdkSurface associated with the event
+ * Returns: (transfer none): The `GdkSurface` associated with the event
*/
GdkSurface *
gdk_event_get_surface (GdkEvent *event)
*
* Returns the seat that originated the event.
*
- * Returns: (nullable) (transfer none): a #GdkSeat.
+ * Returns: (nullable) (transfer none): a `GdkSeat`.
*/
GdkSeat *
gdk_event_get_seat (GdkEvent *event)
*
* Returns the device of an event.
*
- * Returns: (nullable) (transfer none): a #GdkDevice.
+ * Returns: (nullable) (transfer none): a `GdkDevice`
*/
GdkDevice *
gdk_event_get_device (GdkEvent *event)
*
* Retrieves the display associated to the @event.
*
- * Returns: (transfer none) (nullable): a #GdkDisplay
+ * Returns: (transfer none) (nullable): a `GdkDisplay`
*/
GdkDisplay *
gdk_event_get_display (GdkEvent *event)
* GdkMotionEvent:
* @state: (type GdkModifierType): a bit-mask representing the state of
* the modifier keys (e.g. Control, Shift and Alt) set during the motion
- * event. See #GdkModifierType.
+ * event. See [enum@Gdk.ModifierType]
* @x: the x coordinate of the pointer relative to the surface.
* @y: the y coordinate of the pointer relative to the surface.
* @axes: @x, @y translated to the axes of @device, or %NULL if @device is
* GdkButtonEvent:
* @state: (type GdkModifierType): a bit-mask representing the state of
* the modifier keys (e.g. Control, Shift and Alt) and the pointer
- * buttons. See #GdkModifierType.
+ * buttons. See [enum@Gdk.ModifierType]
* @button: the button which was pressed or released, numbered from 1 to 5.
* Normally button 1 is the left mouse button, 2 is the middle button,
* and 3 is the right button. On 2-button mice, the middle button can
* @y: the y coordinate of the pointer relative to the surface.
* @axes: @x, @y translated to the axes of @device, or %NULL if @device is
* the mouse.
- * @tool: a #GdkDeviceTool
+ * @tool: a `GdkDeviceTool`
*
* Used for button press and button release events. The
* @type field will be one of %GDK_BUTTON_PRESS or %GDK_BUTTON_RELEASE,
* GdkTouchEvent:
* @state: (type GdkModifierType): a bit-mask representing the state of
* the modifier keys (e.g. Control, Shift and Alt) and the pointer
- * buttons. See #GdkModifierType
+ * buttons. See [enum@Gdk.ModifierType]
* @x: the x coordinate of the pointer relative to the surface
* @y: the y coordinate of the pointer relative to the surface
* @axes: @x, @y translated to the axes of the event's device, or %NULL
* @y: the y coordinate of the pointer relative to the surface.
* @state: (type GdkModifierType): a bit-mask representing the state of
* the modifier keys (e.g. Control, Shift and Alt) and the pointer
- * buttons. See #GdkModifierType.
+ * buttons. See [enum@Gdk.ModifierType]
* @direction: the direction to scroll to (one of %GDK_SCROLL_UP,
* %GDK_SCROLL_DOWN, %GDK_SCROLL_LEFT, %GDK_SCROLL_RIGHT or
* %GDK_SCROLL_SMOOTH).
* @delta_y: the y coordinate of the scroll delta
* @pointer_emulated: whether the scroll event was the result of
* a pointer emulation
- * @tool: a #GdkDeviceTool
+ * @tool: a `GdkDeviceTool`
* @history: (element-type GdkScrollHistory): array of times and deltas
* for other scroll events that were compressed before delivering the
* current event
* GdkKeyEvent:
* @state: (type GdkModifierType): a bit-mask representing the state of
* the modifier keys (e.g. Control, Shift and Alt) and the pointer
- * buttons. See #GdkModifierType.
+ * buttons. See [enum@Gdk.ModifierType]
* @keycode: the raw code of the key that was pressed or released.
* @translated: the result of translating @keycode. First with the full
* @state, then while ignoring Caps Lock.
* GdkCrossingEvent:
* @state: (type GdkModifierType): a bit-mask representing the state of
* the modifier keys (e.g. Control, Shift and Alt) and the pointer
- * buttons. See #GdkModifierType.
+ * buttons. See [enum@Gdk.ModifierType]
* @mode: the crossing mode (%GDK_CROSSING_NORMAL, %GDK_CROSSING_GRAB,
* %GDK_CROSSING_UNGRAB, %GDK_CROSSING_GTK_GRAB, %GDK_CROSSING_GTK_UNGRAB or
* %GDK_CROSSING_STATE_CHANGED). %GDK_CROSSING_GTK_GRAB, %GDK_CROSSING_GTK_UNGRAB,
/*
* GdkProximityEvent:
- * @tool: the #GdkDeviceTool associated to the event
+ * @tool: the `GdkDeviceTool` associated to the event
*
* A proximity event indicates that a tool of a graphic tablet, or similar
* devices that report proximity, has moved in or out of contact with the
* when the grab surface becomes unviewable (i.e. it or one of its ancestors
* is unmapped), or if the same application grabs the pointer or keyboard
* again. Note that implicit grabs (which are initiated by button presses)
- * can also cause #GdkGrabBrokenEvent events.
+ * can also cause `GdkGrabBrokenEvent` events.
*/
struct _GdkGrabBrokenEvent
{
/*
* GdkDNDEvent:
- * @drop: the #GdkDrop for the current DND operation.
+ * @drop: the `GdkDrop` for the current DND operation.
* @x: the X coordinate of the pointer
* @y: the Y coordinate of the pointer
*
* GdkTouchpadEvent:
* @state: (type GdkModifierType): a bit-mask representing the state of
* the modifier keys (e.g. Control, Shift and Alt) and the pointer
- * buttons. See #GdkModifierType.
+ * buttons. See [enum@Gdk.ModifierType]
* @phase: (type GdkTouchpadGesturePhase): the current phase of the gesture
* @n_fingers: The number of fingers triggering the pinch
* @time: the time of the event in milliseconds
*
* The main way to draw GL content in GTK.
*
- * It takes a render buffer ID (@source_type == #GL_RENDERBUFFER) or a texture
- * id (@source_type == #GL_TEXTURE) and draws it onto @cr with an OVER operation,
+ * It takes a render buffer ID (@source_type == GL_RENDERBUFFER) or a texture
+ * id (@source_type == GL_TEXTURE) and draws it onto @cr with an OVER operation,
* respecting the current clip. The top left corner of the rectangle specified
* by @x, @y, @width and @height will be drawn at the current (0,0) position of
* the `cairo_t`.
* no special effects applied to @cr it will however use a more efficient
* approach.
*
- * For #GL_RENDERBUFFER the code will always fall back to software for buffers
- * with alpha components, so make sure you use #GL_TEXTURE if using alpha.
+ * For GL_RENDERBUFFER the code will always fall back to software for buffers
+ * with alpha components, so make sure you use GL_TEXTURE if using alpha.
*
* Calling this may change the current GL context.
*/
keymap->cache = g_hash_table_new (g_direct_hash, g_direct_equal);
}
-/**
+/*< private >
* gdk_keymap_get_display:
- * @keymap: a #GdkKeymap
+ * @keymap: a `GdkKeymap`
*
- * Retrieves the #GdkDisplay associated to the @keymap.
+ * Retrieves the `GdkDisplay` associated to the @keymap.
*
- * Returns: (transfer none): a #GdkDisplay
+ * Returns: (transfer none): a `GdkDisplay`
*/
GdkDisplay *
gdk_keymap_get_display (GdkKeymap *keymap)
return FALSE;
}
-/**
+/*< private >
* gdk_keymap_get_direction:
- * @keymap: a #GdkKeymap
+ * @keymap: a `GdkKeymap`
*
* Returns the direction of effective layout of the keymap.
*
* Returns: %PANGO_DIRECTION_LTR or %PANGO_DIRECTION_RTL
* if it can determine the direction. %PANGO_DIRECTION_NEUTRAL
* otherwise.
- **/
+ */
PangoDirection
gdk_keymap_get_direction (GdkKeymap *keymap)
{
return GDK_KEYMAP_GET_CLASS (keymap)->get_direction (keymap);
}
-/**
+/*< private >
* gdk_keymap_have_bidi_layouts:
- * @keymap: a #GdkKeymap
+ * @keymap: a `GdkKeymap`
*
* Determines if keyboard layouts for both right-to-left and left-to-right
* languages are in use.
*
* Returns: %TRUE if there are layouts in both directions, %FALSE otherwise
- **/
+ */
gboolean
gdk_keymap_have_bidi_layouts (GdkKeymap *keymap)
{
return GDK_KEYMAP_GET_CLASS (keymap)->have_bidi_layouts (keymap);
}
-/**
+/*< private >
* gdk_keymap_get_caps_lock_state:
- * @keymap: a #GdkKeymap
+ * @keymap: a `GdkKeymap`
*
* Returns whether the Caps Lock modifier is locked.
*
return GDK_KEYMAP_GET_CLASS (keymap)->get_caps_lock_state (keymap);
}
-/**
+/*< private >
* gdk_keymap_get_num_lock_state:
- * @keymap: a #GdkKeymap
+ * @keymap: a `GdkKeymap`
*
* Returns whether the Num Lock modifier is locked.
*
return GDK_KEYMAP_GET_CLASS (keymap)->get_num_lock_state (keymap);
}
-/**
+/*< private >
* gdk_keymap_get_scroll_lock_state:
- * @keymap: a #GdkKeymap
+ * @keymap: a `GdkKeymap`
*
* Returns whether the Scroll Lock modifier is locked.
*
return GDK_KEYMAP_GET_CLASS (keymap)->get_scroll_lock_state (keymap);
}
-/**
+/*< private >
* gdk_keymap_get_modifier_state:
- * @keymap: a #GdkKeymap
+ * @keymap: a `GdkKeymap`
*
* Returns the current modifier state.
*
return 0;
}
-/**
+/*< private >
* gdk_keymap_get_entries_for_keyval:
- * @keymap: a #GdkKeymap
+ * @keymap: a `GdkKeymap`
* @keyval: a keyval, such as %GDK_KEY_a, %GDK_KEY_Up, %GDK_KEY_Return, etc.
* @keys: (out) (array length=n_keys) (transfer full): return location
- * for an array of #GdkKeymapKey
+ * for an array of `GdkKeymapKey`
* @n_keys: return location for number of elements in returned array
*
* Obtains a list of keycode/group/level combinations that will
* right symbol is used. On US keyboards, the shift key changes the
* keyboard level, and there are no groups. A group switch key might
* convert a keyboard between Hebrew to English modes, for example.
- * #GdkEventKey contains a %group field that indicates the active
+ * `GdkEventKey` contains a %group field that indicates the active
* keyboard group. The level is computed from the modifier mask.
* The returned array should be freed
* with g_free().
*keys = (GdkKeymapKey *)&g_array_index (keymap->cached_keys, GdkKeymapKey, offset);
}
-/**
+/*< private >
* gdk_keymap_get_entries_for_keycode:
- * @keymap: a #GdkKeymap
+ * @keymap: a `GdkKeymap`
* @hardware_keycode: a keycode
* @keys: (out) (array length=n_entries) (transfer full) (optional): return
- * location for array of #GdkKeymapKey
+ * location for array of `GdkKeymapKey`
* @keyvals: (out) (array length=n_entries) (transfer full) (optional): return
* location for array of keyvals
* @n_entries: length of @keys and @keyvals
*
* Returns the keyvals bound to @hardware_keycode.
- * The Nth #GdkKeymapKey in @keys is bound to the Nth
+ * The Nth `GdkKeymapKey` in @keys is bound to the Nth
* keyval in @keyvals. Free the returned arrays with g_free().
* When a keycode is pressed by the user, the keyval from
* this list of entries is selected by considering the effective
keys, keyvals, n_entries);
}
-/**
+/*< private >
* gdk_keymap_lookup_key:
- * @keymap: a #GdkKeymap
- * @key: a #GdkKeymapKey with keycode, group, and level initialized
+ * @keymap: a `GdkKeymap`
+ * @key: a `GdkKeymapKey` with keycode, group, and level initialized
*
* Looks up the keyval mapped to a keycode/group/level triplet.
* If no keyval is bound to @key, returns 0. For normal user input,
return GDK_KEYMAP_GET_CLASS (keymap)->lookup_key (keymap, key);
}
-/**
+/*< private >
* gdk_keymap_translate_keyboard_state:
- * @keymap: a #GdkKeymap
+ * @keymap: a `GdkKeymap`
* @hardware_keycode: a keycode
* @state: a modifier state
* @group: active keyboard group
* @consumed_modifiers: (out) (optional): return location for modifiers
* that were used to determine the group or level
*
- * Translates the contents of a #GdkEventKey into a keyval, effective
+ * Translates the contents of a `GdkEventKey` into a keyval, effective
* group, and level. Modifiers that affected the translation and
* are thus unavailable for application use are returned in
* @consumed_modifiers.
* groups and levels. The @effective_group is the group that was
* actually used for the translation; some keys such as Enter are not
* affected by the active keyboard group. The @level is derived from
- * @state. For convenience, #GdkEventKey already contains the translated
+ * @state. For convenience, `GdkEventKey` already contains the translated
* keyval, so this function isn’t as useful as you might think.
*
* @consumed_modifiers gives modifiers that should be masked outfrom @state
*
* Obtains the upper- and lower-case versions of the keyval @symbol.
*
- * Examples of keyvals are #GDK_KEY_a, #GDK_KEY_Enter, #GDK_KEY_F1, etc.
+ * Examples of keyvals are `GDK_KEY_a`, `GDK_KEY_Enter`, `GDK_KEY_F1`, etc.
*/
void
gdk_keyval_convert_case (guint symbol,
* This is the format provided by [method@Gdk.Texture.download].
* It is equal to %CAIRO_FORMAT_ARGB32.
*
- * Be aware that unlike the #GdkMemoryFormat values, this format
+ * Be aware that unlike the `GdkMemoryFormat` values, this format
* is different for different endianness.
*/
#if G_BYTE_ORDER == G_LITTLE_ENDIAN
* Returns a paintable that has the given intrinsic size and draws nothing.
*
* This is often useful for implementing the
- * #GdkPaintableInterface.get_current_image() virtual function
+ * [vfunc@Gdk.Paintable.get_current_image] virtual function
* when the paintable is in an incomplete state (like a
* [class@Gtk.MediaStream] before receiving the first frame).
*
* Note that apart from the [vfunc@Gdk.PaintableInterface.snapshot] function,
* no virtual function of this interface is mandatory to implement, though it
* is a good idea to implement [vfunc@Gdk.PaintableInterface.get_current_image]
- * for non-static paintables and #GdkPaintableInterface.get_flags() if the
+ * for non-static paintables and [vfunc@Gdk.PaintableInterface.get_flags] if the
* image is not dynamic as the default implementation returns no flags and
* that will make the implementation likely quite slow.
*/
/**
* gdk_pipe_io_stream_new:
*
- * Creates a #GIOStream whose input- and output-stream behave like a pipe.
+ * Creates a `GIOStream` whose input- and output-stream behave like a pipe.
+ *
* Data written into the output stream becomes available for reading on
* the input stream.
*
* Note that this is data transfer in the opposite direction to
* g_output_stream_splice().
*
- * Returns: a new #GIOStream
- **/
+ * Returns: a new `GIOStream`
+ */
GIOStream *
gdk_pipe_io_stream_new (void)
{
* stages will almost certainly convert the pixbuf back into a texture
* to draw it on screen.
*
- * Returns: (transfer full) (nullable): a new #GdkPixbuf
+ * Returns: (transfer full) (nullable): a new `GdkPixbuf`
*/
GdkPixbuf *
gdk_pixbuf_get_from_texture (GdkTexture *texture)
* @height: the unconstrained popup height to layout
* @layout: the `GdkPopupLayout` object used to layout
*
- * Present @popup after having processed the #GdkPopupLayout rules.
+ * Present @popup after having processed the `GdkPopupLayout` rules.
*
* If the popup was previously now showing, it will be showed,
* otherwise it will change position according to @layout.
* @x: X coordinate
* @y: Y coordinate
*
- * Returns #TRUE if @rect contains the point described by @x and @y.
+ * Returns %TRUE if @rect contains the point described by @x and @y.
*
- * Returns: #TRUE if @rect contains the point
+ * Returns: %TRUE if @rect contains the point
**/
gboolean
gdk_rectangle_contains_point (const GdkRectangle *rect,
/**
* gdk_seat_get_devices:
- * @seat: a #GdkSeat
+ * @seat: a `GdkSeat`
* @capabilities: capabilities to get devices for
*
* Returns the devices that match the given capabilities.
* gdk_surface_get_device_position:
* @surface: a `GdkSurface`
* @device: pointer `GdkDevice` to query to
- * @x: (out) (optional): return locatio for the X coordinate of @device
+ * @x: (out) (optional): return location for the X coordinate of @device
* @y: (out) (optional): return location for the Y coordinate of @device
* @mask: (out) (optional): return location for the modifier mask
*
* GTK will update this property automatically if the @surface background
* is opaque, as we know where the opaque regions are. If your surface
* background is not opaque, please update this property in your
- * #GtkWidgetClass.css_changed() handler.
+ * [vfunc@Gtk.Widget.css_changed] handler.
*/
void
gdk_surface_set_opaque_region (GdkSurface *surface,
/**
* gdk_toplevel_begin_move:
- * @toplevel: a #GdkToplevel
+ * @toplevel: a `GdkToplevel`
* @device: the device used for the operation
* @button: the button being used to drag, or 0 for a keyboard-initiated drag
* @x: surface X coordinate of mouse click that began the drag
* The size is in ”application pixels”, not
* ”device pixels” (see gdk_surface_get_scale_factor()).
*
- * Returns: (transfer full): newly created instance of #GdkToplevelLayout
+ * Returns: (transfer full): newly created instance of `GdkToplevelLayout`
*/
GdkToplevelLayout *
gdk_toplevel_layout_new (void)
/**
* gdk_toplevel_layout_ref:
- * @layout: a #GdkToplevelLayout
+ * @layout: a `GdkToplevelLayout`
*
* Increases the reference count of @layout.
*
/**
* gdk_toplevel_layout_unref:
- * @layout: a #GdkToplevelLayout
+ * @layout: a `GdkToplevelLayout`
*
* Decreases the reference count of @layout.
*/
/**
* gdk_toplevel_layout_copy:
- * @layout: a #GdkToplevelLayout
+ * @layout: a `GdkToplevelLayout`
*
- * Create a new #GdkToplevelLayout and copy the contents of @layout into it.
+ * Create a new `GdkToplevelLayout` and copy the contents of @layout into it.
*
* Returns: (transfer full): a copy of @layout.
*/
/**
* gdk_toplevel_layout_equal:
- * @layout: a #GdkToplevelLayout
- * @other: another #GdkToplevelLayout
+ * @layout: a `GdkToplevelLayout`
+ * @other: another `GdkToplevelLayout`
*
* Check whether @layout and @other has identical layout properties.
*
/**
* gdk_toplevel_layout_set_resizable:
- * @layout: a #GdkToplevelLayout
+ * @layout: a `GdkToplevelLayout`
* @resizable: %TRUE to allow resizing
*
* Sets whether the layout should allow the user
/**
* gdk_toplevel_layout_get_resizable:
- * @layout: a #GdkToplevelLayout
+ * @layout: a `GdkToplevelLayout`
*
* Returns whether the layout should allow the user
* to resize the surface.
/**
* gdk_toplevel_layout_set_maximized:
- * @layout: a #GdkToplevelLayout
+ * @layout: a `GdkToplevelLayout`
* @maximized: %TRUE to maximize
*
* Sets whether the layout should cause the surface
/**
* gdk_toplevel_layout_get_maximized:
- * @layout: a #GdkToplevelLayout
+ * @layout: a `GdkToplevelLayout`
* @maximized: (out): set to %TRUE if the toplevel should be maximized
*
* If the layout specifies whether to the toplevel should go maximized,
/**
* gdk_toplevel_layout_set_fullscreen:
- * @layout: a #GdkToplevelLayout
+ * @layout: a `GdkToplevelLayout`
* @fullscreen: %TRUE to fullscreen the surface
* @monitor: (nullable): the monitor to fullscreen on
*
/**
* gdk_toplevel_layout_get_fullscreen:
- * @layout: a #GdkToplevelLayout
+ * @layout: a ``GdkToplevelLayout`
* @fullscreen: (out): location to store whether the toplevel should be fullscreen
*
* If the layout specifies whether to the toplevel should go fullscreen,
/**
* gdk_toplevel_layout_get_fullscreen_monitor:
- * @layout: a #GdkToplevelLayout
+ * @layout: a `GdkToplevelLayout`
*
* Returns the monitor that the layout is fullscreening
* the surface on.
* @GDK_GRAVITY_STATIC: the reference point is at the top left corner of the
* surface itself, ignoring window manager decorations.
*
- * Defines the reference point of a surface and is used in #GdkPopupLayout.
+ * Defines the reference point of a surface and is used in `GdkPopupLayout`.
*/
typedef enum
{
* compiled in.
* @GDK_VULKAN_ERROR_NOT_AVAILABLE: Vulkan support is not available on this Surface
*
- * Error enumeration for #GdkVulkanContext.
+ * Error enumeration for `GdkVulkanContext`.
*/
typedef enum {
GDK_VULKAN_ERROR_UNSUPPORTED,
/**
* gdk_vulkan_context_get_device:
- * @context: a #GdkVulkanContext
+ * @context: a `GdkVulkanContext`
*
* Gets the Vulkan device that this context is using.
*
/**
* gdk_display_link_source_new:
*
- * Creates a new #GSource that will activate the dispatch function upon
+ * Creates a new `GSource` that will activate the dispatch function upon
* notification from a CVDisplayLink that a new frame should be drawn.
*
* Effort is made to keep the transition from the high-priority
* somewhat non-ideal since the best case would be to do the drawing
* from the high-priority thread.
*
- * Returns: (transfer full): A newly created #GSource.
+ * Returns: (transfer full): A newly created `GSource`
*/
GSource *
gdk_display_link_source_new (void)
/*
* gdk_wayland_display_prefers_ssd:
- * @display: (type GdkWaylandDisplay): a #GdkDisplay
+ * @display: (type GdkWaylandDisplay): a `GdkDisplay`
*
* Checks whether the Wayland compositor prefers to draw the window
* decorations or if it leaves decorations to the application.
/*
* gdk_wayland_surface_inhibit_shortcuts:
- * @surface: (type GdkWaylandSurface): a #GdkSurface
+ * @surface: (type GdkWaylandSurface): a `GdkSurface`
* @seat: the seat to inhibit
*
* Inhibits the shortcuts coming from the given @seat.
/*
* gdk_wayland_surface_restore_shortcuts:
- * @surface: (type GdkWaylandSurface): a #GdkSurface
+ * @surface: (type GdkWaylandSurface): a `GdkSurface`
* @seat: the seat to inhibit
*
* Restores the shortcuts on the given @seat inhibited by calling
/**
* gdk_win32_display_get_win32hcursor:
- * @display: (type GdkWin32Display): a #GdkDisplay
- * @cursor: a #GdkCursor.
- *
- * Returns the Win32 HCURSOR wrapper object belonging to a #GdkCursor,
+ * @display: (type GdkWin32Display): a `GdkDisplay`
+ * @cursor: a `GdkCursor`
+ *
+ * Returns the Win32 HCURSOR wrapper object belonging to a `GdkCursor`,
* potentially creating the cursor object.
*
* Be aware that the returned cursor may not be unique to @cursor.
* It may for example be shared with its fallback cursor.
- *
- * Returns: a GdkWin32HCursor.
- **/
+ *
+ * Returns: a GdkWin32HCursor
+ */
GdkWin32HCursor *
gdk_win32_display_get_win32hcursor (GdkWin32Display *display,
GdkCursor *cursor)
/**
* gdk_win32_display_add_filter:
- * @display: a #GdkWin32Display
+ * @display: a `GdkWin32Display`
* @function: filter callback
* @data: data to pass to filter callback
*
/**
* _gdk_win32_message_filter_unref:
- * @display: A #GdkWin32Display
+ * @display: A `GdkWin32Display`
* @filter: A message filter
*
* Release a reference to @filter. Note this function may
/**
* gdk_win32_display_remove_filter:
- * @display: A #GdkWin32Display
+ * @display: A `GdkWin32Display`
* @function: previously-added filter function
* @data: user data for previously-added filter function
*
* change. Custom cursors constructed with [ctor@Gdk.Cursor.new_from_texture]
* will have to be handled by the application (GTK applications can
* learn about cursor theme changes by listening for change notification
- * for the corresponding #GtkSetting).
+ * for the corresponding `GtkSetting`).
*/
void
gdk_win32_display_set_cursor_theme (GdkDisplay *display,
/**
* gdk_win32_display_get_wgl_version:
- * @display: a #GdkDisplay
+ * @display: a `GdkDisplay`
* @major: (out): return location for the WGL major version
* @minor: (out): return location for the WGL minor version
*
* @GDK_WIN32_MESSAGE_FILTER_CONTINUE: event not handled, continue processing.
* @GDK_WIN32_MESSAGE_FILTER_REMOVE: event handled, terminate processing.
*
- * Specifies the result of applying a #GdkWin32MessageFilterFunc to a Windows message.
+ * Specifies the result of applying a `GdkWin32MessageFilterFunc` to a Windows message.
*/
typedef enum {
GDK_WIN32_MESSAGE_FILTER_CONTINUE, /* Message not handled, continue processing */
* processed by GDK Win32 backend.
*
* The @return_value must be set, if this function returns
- * #GDK_WIN32_MESSAGE_FILTER_REMOVE, otherwise it is ignored.
+ * `GDK_WIN32_MESSAGE_FILTER_REMOVE`, otherwise it is ignored.
*
- * The event translation and message filtering are orthogonal -
+ * The event translation and message filtering are orthogonal -
* if a filter wants a GDK event queued, it should do that itself.
*
- * Returns: a #GdkWin32MessageFilterReturn value.
+ * Returns: a `GdkWin32MessageFilterReturn` value.
*/
typedef GdkWin32MessageFilterReturn (*GdkWin32MessageFilterFunc) (GdkWin32Display *display,
MSG *message,
* change. Custom cursors constructed with [ctor@Gdk.Cursor.new_from_texture]
* will have to be handled by the application (GTK applications can learn
* about cursor theme changes by listening for change notification
- * for the corresponding #GtkSetting).
+ * for the corresponding `GtkSetting`).
*/
void
gdk_x11_display_set_cursor_theme (GdkDisplay *display,
/**
* gdk_x11_display_get_xcursor:
- * @display: (type GdkX11Display): a #GdkDisplay
- * @cursor: a #GdkCursor.
- *
- * Returns the X cursor belonging to a #GdkCursor, potentially
+ * @display: (type GdkX11Display): a `GdkDisplay`
+ * @cursor: a `GdkCursor`
+ *
+ * Returns the X cursor belonging to a `GdkCursor`, potentially
* creating the cursor.
*
* Be aware that the returned cursor may not be unique to @cursor.
* It may for example be shared with its fallback cursor. On old
* X servers that don't support the XCursor extension, all cursors
* may even fall back to a few default cursors.
- *
+ *
* Returns: an Xlib Cursor.
- **/
+ */
Cursor
gdk_x11_display_get_xcursor (GdkDisplay *display,
GdkCursor *cursor)
g_error ("XInput2 support not found on display");
}
-/*
+/**
* gdk_x11_device_manager_lookup:
- * @device_manager: (type GdkX11DeviceManagerXI2): a #GdkDeviceManager
+ * @device_manager: (type GdkX11DeviceManagerXI2): a `GdkDeviceManager`
* @device_id: a device ID, as understood by the XInput2 protocol
*
- * Returns the #GdkDevice that wraps the given device ID.
+ * Returns the `GdkDevice` that wraps the given device ID.
*
* Returns: (transfer none) (nullable) (type GdkX11DeviceXI2): The
- * `GdkDevice` wrapping the device ID,
- * or %NULL if the given ID doesn’t currently represent a device.
- **/
+ * `GdkDevice` wrapping the device ID, or %NULL if the given ID
+ * doesn’t currently represent a device.
+ */
GdkDevice *
gdk_x11_device_manager_lookup (GdkX11DeviceManagerXI2 *device_manager,
int device_id)
/**
* gdk_x11_display_set_program_class:
- * @display: a #GdkDisplay
+ * @display: a `GdkDisplay`
* @program_class: a string
*
* Sets the program class.
/**
* gdk_x11_display_get_default_group:
- * @display: (type GdkX11Display): a #GdkDisplay
+ * @display: (type GdkX11Display): a `GdkDisplay`
*
* Returns the default group leader surface for all toplevel surfaces
* on @display. This surface is implicitly created by GDK.
/**
* gdk_x11_display_grab:
- * @display: (type GdkX11Display): a #GdkDisplay
- *
- * Call XGrabServer() on @display.
- * To ungrab the display again, use gdk_x11_display_ungrab().
+ * @display: (type GdkX11Display): a `GdkDisplay`
+ *
+ * Call XGrabServer() on @display.
+ * To ungrab the display again, use gdk_x11_display_ungrab().
*
* gdk_x11_display_grab()/gdk_x11_display_ungrab() calls can be nested.
**/
/**
* gdk_x11_display_ungrab:
- * @display: (type GdkX11Display): a #GdkDisplay
- *
- * Ungrab @display after it has been grabbed with
- * gdk_x11_display_grab().
+ * @display: (type GdkX11Display): a `GdkDisplay`
+ *
+ * Ungrab @display after it has been grabbed with
+ * gdk_x11_display_grab().
**/
void
gdk_x11_display_ungrab (GdkDisplay *display)
/**
* gdk_x11_lookup_xdisplay:
* @xdisplay: a pointer to an X Display
- *
- * Find the #GdkDisplay corresponding to @xdisplay, if any exists.
- *
- * Returns: (transfer none) (type GdkX11Display): the #GdkDisplay, if found, otherwise %NULL.
+ *
+ * Find the `GdkDisplay` corresponding to @xdisplay, if any exists.
+*
+ * Returns: (transfer none) (type GdkX11Display): the `GdkDisplay`, if found, otherwise %NULL.
**/
GdkDisplay *
gdk_x11_lookup_xdisplay (Display *xdisplay)
/*
* _gdk_x11_display_screen_for_xrootwin:
- * @display: a #GdkDisplay
+ * @display: a `GdkDisplay`
* @xrootwin: window ID for one of the screen’s of the display.
*
- * Given the root window ID of one of the screen’s of a #GdkDisplay,
+ * Given the root window ID of one of the screen’s of a `GdkDisplay`,
* finds the screen.
*
- * Returns: (transfer none) (nullable): the #GdkX11Screen
- * corresponding to @xrootwin
+ * Returns: (transfer none): the `GdkX11Screen` corresponding to @xrootwin
*/
GdkX11Screen *
_gdk_x11_display_screen_for_xrootwin (GdkDisplay *display,
/**
* gdk_x11_display_get_xdisplay:
- * @display: (type GdkX11Display): a #GdkDisplay
+ * @display: (type GdkX11Display): a `GdkDisplay`
*
- * Returns the X display of a #GdkDisplay.
+ * Returns the X display of a `GdkDisplay`.
*
* Returns: (transfer none): an X display
*/
/**
* gdk_x11_display_get_xscreen:
- * @display: (type GdkX11Display): a #GdkDisplay
+ * @display: (type GdkX11Display): a `GdkDisplay`
*
- * Returns the X Screen used by #GdkDisplay.
+ * Returns the X Screen used by `GdkDisplay`.
*
* Returns: (transfer none): an X Screen
*/
/**
* gdk_x11_display_get_xrootwindow:
- * @display: (type GdkX11Display): a #GdkDisplay
+ * @display: (type GdkX11Display): a `GdkDisplay`
*
- * Returns the root X window used by #GdkDisplay.
+ * Returns the root X window used by `GdkDisplay`.
*
* Returns: an X Window
*/
/**
* gdk_x11_display_broadcast_startup_message:
- * @display: (type GdkX11Display): a #GdkDisplay
+ * @display: (type GdkX11Display): a `GdkDisplay`
* @message_type: startup notification message type ("new", "change",
* or "remove")
* @...: a list of key/value pairs (as strings), terminated by a
/**
* gdk_x11_display_get_user_time:
- * @display: (type GdkX11Display): a #GdkDisplay
+ * @display: (type GdkX11Display): a `GdkDisplay`
*
- * Returns the timestamp of the last user interaction on
+ * Returns the timestamp of the last user interaction on
* @display. The timestamp is taken from events caused
- * by user interaction such as key presses or pointer
+ * by user interaction such as key presses or pointer
* movements. See gdk_x11_surface_set_user_time().
*
- * Returns: the timestamp of the last user interaction
+ * Returns: the timestamp of the last user interaction
*/
guint32
gdk_x11_display_get_user_time (GdkDisplay *display)
/**
* gdk_x11_display_get_startup_notification_id:
- * @display: (type GdkX11Display): a #GdkDisplay
+ * @display: (type GdkX11Display): a `GdkDisplay`
*
* Gets the startup notification ID for a display.
*
/**
* gdk_x11_display_set_startup_notification_id:
- * @display: (type GdkX11Display): a #GdkDisplay
+ * @display: (type GdkX11Display): a `GdkDisplay`
* @startup_id: the startup notification ID (must be valid utf8)
*
* Sets the startup notification ID for a display.
/**
* gdk_x11_display_error_trap_push:
- * @display: (type GdkX11Display): a #GdkDisplay
+ * @display: (type GdkX11Display): a `GdkDisplay`
*
* Begins a range of X requests on @display for which X error events
* will be ignored. Unignored errors (when no trap is pushed) will abort
/**
* gdk_x11_display_get_screen:
- * @display: (type GdkX11Display): a #GdkX11Display
+ * @display: (type GdkX11Display): a `GdkX11Display`
*
- * Retrieves the #GdkX11Screen of the @display.
+ * Retrieves the `GdkX11Screen` of the @display.
*
- * Returns: (transfer none): the #GdkX11Screen
+ * Returns: (transfer none): the `GdkX11Screen`
*/
GdkX11Screen *
gdk_x11_display_get_screen (GdkDisplay *display)
* that GDK expects to translate, you may break GDK and/or GTK+ in
* interesting ways. You have been warned.
*
- * If you want this signal handler to queue a #GdkEvent, you can use
+ * If you want this signal handler to queue a `GdkEvent`, you can use
* gdk_display_put_event().
*
* If you are interested in X GenericEvents, bear in mind that
* @GDK_DRAG_PROTO_ROOTWIN: An extension to the Xdnd protocol for
* unclaimed root window drops.
*
- * Used in #GdkDrag to indicate the protocol according to
+ * Used in `GdkDrag` to indicate the protocol according to
* which DND is done.
*/
typedef enum
/**
* gdk_x11_display_get_egl_version:
- * @display: (type GdkX11Display): a #GdkDisplay
+ * @display: (type GdkX11Display): a `GdkDisplay`
* @major: (out): return location for the EGL major version
* @minor: (out): return location for the EGL minor version
*
/**
* gdk_x11_display_get_glx_version:
- * @display: (type GdkX11Display): a #GdkDisplay
+ * @display: (type GdkX11Display): a `GdkDisplay`
* @major: (out): return location for the GLX major version
* @minor: (out): return location for the GLX minor version
*
/*< private >
* gdk_x11_keymap_get_group_for_state:
- * @keymap: (type GdkX11Keymap): a #GdkX11Keymap
+ * @keymap: (type GdkX11Keymap): a `GdkX11Keymap`
* @state: raw state returned from X
*
* Extracts the group from the state field sent in an X Key event.
- * This is only needed for code processing raw X events, since #GdkEventKey
+ * This is only needed for code processing raw X events, since `GdkEventKey`
* directly includes an is_modifier field.
*
* Returns: the index of the active keyboard group for the event
/*< private >
* gdk_x11_keymap_key_is_modifier:
- * @keymap: (type GdkX11Keymap): a #GdkX11Keymap
+ * @keymap: (type GdkX11Keymap): a `GdkX11Keymap`
* @keycode: the hardware keycode from a key event
*
* Determines whether a particular key code represents a key that
* is a modifier. That is, it’s a key that normally just affects
* the keyboard state and the behavior of other keys rather than
* producing a direct effect itself. This is only needed for code
- * processing raw X events, since #GdkEventKey directly includes
+ * processing raw X events, since `GdkEventKey` directly includes
* an is_modifier field.
*
* Returns: %TRUE if the hardware keycode is a modifier key
/*
* _gdk_x11_surface_grab_check_unmap:
- * @surface: a #GdkSurface
+ * @surface: a `GdkSurface`
* @serial: serial from Unmap event (or from NextRequest(display)
* if the unmap is being done by this client.)
*
/*
* _gdk_x11_surface_grab_check_destroy:
- * @surface: a #GdkSurface
+ * @surface: a `GdkSurface`
*
* Checks to see if surface is the current grab surface, and if
* so, clear the current grab surface.
/**
* gdk_x11_monitor_get_output:
- * @monitor: (type GdkX11Monitor): a #GdkMonitor
+ * @monitor: (type GdkX11Monitor): a `GdkMonitor`
*
* Returns the XID of the Output corresponding to @monitor.
*
/**
* gdk_x11_get_xatom_by_name_for_display:
- * @display: (type GdkX11Display): a #GdkDisplay
+ * @display: (type GdkX11Display): a `GdkDisplay`
* @atom_name: a string
*
- * Returns the X atom for a #GdkDisplay corresponding to @atom_name.
+ * Returns the X atom for a `GdkDisplay` corresponding to @atom_name.
* This function caches the result, so if called repeatedly it is much
* faster than XInternAtom(), which is a round trip to the server each time.
*
- * Returns: a X atom for a #GdkDisplay
+ * Returns: a X atom for a `GdkDisplay`
**/
Atom
gdk_x11_get_xatom_by_name_for_display (GdkDisplay *display,
/**
* gdk_x11_get_xatom_name_for_display:
- * @display: (type GdkX11Display): the #GdkDisplay where @xatom is defined
+ * @display: (type GdkX11Display): the `GdkDisplay` where @xatom is defined
* @xatom: an X atom
*
* Returns the name of an X atom for its display. This
/**
* gdk_x11_screen_get_monitor_output:
- * @screen: a #GdkX11Screen
+ * @screen: a `GdkX11Screen`
* @monitor_num: number of the monitor, between 0 and gdk_screen_get_n_monitors (screen)
*
* Gets the XID of the specified output/monitor.
/**
* gdk_x11_screen_get_xscreen:
- * @screen: a #GdkX11Screen
+ * @screen: a `GdkX11Screen`
*
- * Returns the screen of a #GdkX11Screen.
+ * Returns the screen of a `GdkX11Screen`.
*
* Returns: (transfer none): an Xlib Screen*
*/
/**
* gdk_x11_screen_supports_net_wm_hint:
- * @screen: the relevant #GdkX11Screen.
+ * @screen: the relevant `GdkX11Screen`.
* @property_name: name of the WM property
*
* This function is specific to the X11 backend of GDK, and indicates
* is that your application can start up before the window manager
* does when the user logs in, and before the window manager starts
* gdk_x11_screen_supports_net_wm_hint() will return %FALSE for every property.
- * You can monitor the window_manager_changed signal on #GdkX11Screen to detect
+ * You can monitor the window_manager_changed signal on `GdkX11Screen` to detect
* a window manager change.
*
* Returns: %TRUE if the window manager supports @property
/**
* gdk_x11_screen_get_window_manager_name:
- * @screen: a #GdkX11Screen
+ * @screen: a `GdkX11Screen`
*
* Returns the name of the window manager for @screen.
*
/**
* gdk_x11_screen_get_number_of_desktops:
- * @screen: a #GdkX11Screen
+ * @screen: a `GdkX11Screen`
*
* Returns the number of workspaces for @screen when running under a
* window manager that supports multiple workspaces, as described
/**
* gdk_x11_screen_get_current_desktop:
- * @screen: a #GdkX11Screen
+ * @screen: a `GdkX11Screen`
*
* Returns the current workspace for @screen when running under a
* window manager that supports multiple workspaces, as described
/**
* gdk_x11_display_text_property_to_text_list:
- * @display: (type GdkX11Display): The #GdkDisplay where the encoding is defined
+ * @display: (type GdkX11Display): The `GdkDisplay` where the encoding is defined
* @encoding: a string representing the encoding. The most
* common values for this are "STRING", or "COMPOUND_TEXT".
* This is value used as the type for the property
/**
* gdk_x11_display_string_to_compound_text:
- * @display: (type GdkX11Display): the #GdkDisplay where the encoding is defined
+ * @display: (type GdkX11Display): the `GdkDisplay` where the encoding is defined
* @str: a nul-terminated string
* @encoding: (out) (transfer none): location to store the encoding
* (to be used as the type for the property)
/**
* gdk_x11_display_utf8_to_compound_text:
- * @display: (type GdkX11Display): a #GdkDisplay
+ * @display: (type GdkX11Display): a `GdkDisplay`
* @str: a UTF-8 string
* @encoding: (out) (transfer none): location to store resulting encoding
* @format: (out): location to store format of the result
/*
* gdk_x11_surface_update_size:
- * @self: a #GdkX11Surface
+ * @self: a `GdkX11Surface`
* @width: the new width of the surface
* @height: the new height of the surface
* @scale: the new scale of the surface
/**
* gdk_x11_surface_move_to_current_desktop:
- * @surface: (type GdkX11Surface): a #GdkSurface
+ * @surface: (type GdkX11Surface): a `GdkSurface`
*
* Moves the surface to the correct workspace when running under a
* window manager that supports multiple workspaces, as described
/**
* gdk_x11_surface_get_desktop:
- * @surface: (type GdkX11Surface): a #GdkSurface
+ * @surface: (type GdkX11Surface): a `GdkSurface`
*
* Gets the number of the workspace @surface is on.
*
/**
* gdk_x11_surface_move_to_desktop:
- * @surface: (type GdkX11Surface): a #GdkSurface
+ * @surface: (type GdkX11Surface): a `GdkSurface`
* @desktop: the number of the workspace to move the surface to
*
* Moves the surface to the given workspace when running unde a
/**
* gdk_x11_surface_set_skip_taskbar_hint:
- * @surface: (type GdkX11Surface): a native #GdkSurface
+ * @surface: (type GdkX11Surface): a native `GdkSurface`
* @skips_taskbar: %TRUE to skip taskbars
*
* Sets a hint on @surface that taskbars should not
/**
* gdk_x11_surface_set_skip_pager_hint:
- * @surface: (type GdkX11Surface): a #GdkSurface
+ * @surface: (type GdkX11Surface): a `GdkSurface`
* @skips_pager: %TRUE to skip pagers
*
* Sets a hint on @surface that pagers should not
/**
* gdk_x11_surface_set_urgency_hint:
- * @surface: (type GdkX11Surface): a native #GdkSurface
+ * @surface: (type GdkX11Surface): a native `GdkSurface`
* @urgent: %TRUE to indicate urgenct attention needed
*
* Sets a hint on @surface that it needs user attention.
/**
* gdk_x11_surface_set_user_time:
- * @surface: (type GdkX11Surface): A toplevel #GdkSurface
+ * @surface: (type GdkX11Surface): A toplevel `GdkSurface`
* @timestamp: An XServer timestamp to which the property should be set
*
* The application can use this call to update the _NET_WM_USER_TIME
/**
* gdk_x11_surface_set_utf8_property:
- * @surface: (type GdkX11Surface): a #GdkSurface
+ * @surface: (type GdkX11Surface): a `GdkSurface`
* @name: Property name, will be interned as an X atom
* @value: (nullable): Property value, or %NULL to delete
*
/**
* gdk_x11_surface_set_theme_variant:
- * @surface: (type GdkX11Surface): a #GdkSurface
+ * @surface: (type GdkX11Surface): a `GdkSurface`
* @variant: the theme variant to export
*
* GTK applications can request a dark theme variant. In order to
/**
* gdk_x11_surface_get_group:
- * @surface: (type GdkX11Surface): The #GdkSurface
+ * @surface: (type GdkX11Surface): The `GdkSurface`
*
* Returns the group this surface belongs to.
*
/**
* gdk_x11_surface_set_group:
- * @surface: (type GdkX11Surface): a native #GdkSurface
- * @leader: a #GdkSurface
+ * @surface: (type GdkX11Surface): a native `GdkSurface`
+ * @leader: a `GdkSurface`
*
* Sets the group leader of @surface to be @leader.
* See the ICCCM for details.
/**
* gdk_x11_surface_get_xid:
- * @surface: (type GdkX11Surface): a native #GdkSurface.
+ * @surface: (type GdkX11Surface): a native `GdkSurface`.
*
- * Returns the X resource (surface) belonging to a #GdkSurface.
+ * Returns the X resource (surface) belonging to a `GdkSurface`.
*
* Returns: the ID of @drawable’s X resource.
**/
/**
* gdk_x11_surface_set_frame_sync_enabled:
- * @surface: (type GdkX11Surface): a native #GdkSurface
+ * @surface: (type GdkX11Surface): a native `GdkSurface`
* @frame_sync_enabled: whether frame-synchronization should be enabled
*
* This function can be used to disable frame synchronization for a surface.
/*< private >
* gdk_x11_screen_lookup_visual:
- * @screen: a #GdkX11Screen.
+ * @screen: a `GdkX11Screen`
* @xvisualid: an X Visual ID.
*
- * Looks up the #GdkVisual for a particular screen and X Visual ID.
+ * Looks up the `GdkVisual` for a particular screen and X Visual ID.
*
- * Returns: (transfer none) (nullable) (type GdkX11Visual): the #GdkVisual
+ * Returns: (transfer none) (nullable) (type GdkX11Visual): the `GdkVisual`
*/
GdkX11Visual *
gdk_x11_screen_lookup_visual (GdkX11Screen *x11_screen,
/*< private >
* gdk_x11_visual_get_xvisual:
- * @visual: a #GdkX11Visual.
+ * @visual: a `GdkX11Visual`
*
- * Returns the X visual belonging to a #GdkX11Visual.
+ * Returns the X visual belonging to a `GdkX11Visual`.
*
* Returns: (transfer none): an Xlib Visual*.
**/
/**
* GDK_DISPLAY_XDISPLAY:
- * @display: a #GdkDisplay
+ * @display: a `GdkDisplay`
*
- * Returns the display of a #GdkDisplay.
+ * Returns the display of a `GdkDisplay`.
*
* Returns: an Xlib Display*
*/
/**
* GDK_SURFACE_XDISPLAY:
- * @win: a #GdkSurface.
+ * @win: a `GdkSurface`
*
- * Returns the display of a #GdkSurface.
+ * Returns the display of a `GdkSurface`.
*
* Returns: an Xlib Display*.
*/
/**
* GDK_SURFACE_XID:
- * @win: a #GdkSurface.
+ * @win: a `GdkSurface`
*
- * Returns the X window belonging to a #GdkSurface.
+ * Returns the X window belonging to a `GdkSurface`.
*
* Returns: the Xlib Window of @win.
*/
* @xid: XID to stuff into the pointer
*
* Converts an XID into a @gpointer. This is useful with data structures
- * that use pointer arguments such as #GHashTable. Use GDK_POINTER_TO_XID()
+ * that use pointer arguments such as `GHashTable`. Use GDK_POINTER_TO_XID()
* to convert the argument back to an XID.
*/
#define GDK_XID_TO_POINTER(xid) GUINT_TO_POINTER(xid)
projects / gtk4.git / commitdiff